from django.http import HttpResponse
from django.shortcuts import render # 导入 render 用于渲染模板
from django.shortcuts import redirect # 导入 redirect 用于重定向页面
from django.views import View

from spider.models import YearDistribution # 导入 View 基类，用于类视图
from .forms import RegisterForm, LoginForm # 导入自定义的注册表单和登录表单
from .models import User # 导入用户模型（注意如果在同目录需要使用 .models）
from django.contrib.auth import login
from .tasks import send_email
from django.contrib.auth.decorators import login_required 

# Create your views here.
# 首页视图函数
def index(request):
    """
    渲染首页视图。
    """
    # 从 session 中获取当前用户名，若不存在则默认值为 0（防止报错）
    username = request.session.get('username', default=0)
    # 根据用户名查找用户对象（使用 first() 取第一个，避免报错）
    user = User.objects.filter(username=username).first()
    # 渲染 index.html 页面，并将 user 对象传入模板
    return render(request, 'index.html', {'user': user})
# 注册页面的类视图
class RegisterView(View):
    # 处理 GET 请求（用户访问注册页面时触发）
    def get(self, request):
        form = RegisterForm() # 实例化空的注册表单
        return render(request, 'register.html', {'form': form}) # 渲染注册页面并传入空表单
    # 处理 POST 请求（用户提交注册信息时触发）
    def post(self, request):
        form = RegisterForm(request.POST) # 用 POST 数据构建表单实例
        if form.is_valid(): # 检查表单数据是否合法
            form.save() # 如果合法则保存到数据库
            return redirect('app:login') # 跳转到登录页面（app 为命名空间）
        return render(request, 'register.html', {'form': form}) # 验证失败则重新渲染页面并保留错误信息
# 登录页面的类视图
class LoginView(View):
    # 处理 GET 请求（访问登录页面）
    def get(self, request):
        form = LoginForm() # 实例化空登录表单
        return render(request, 'login.html', {'form': form}) # 渲染登录页面并传入空表单
    # 处理 POST 请求（用户提交登录信息）
    # def post(self, request):
    #     form = LoginForm(request.POST)
    #     if form.is_valid():
    #         username = form.cleaned_data.get('username')
    #         user = User.objects.get(username=username)
    #         login(request, user) # 使用 Django 的 login 函数
    #         request.session['username'] = username
    #         return redirect('app:index')
    #     return render(request, 'login.html', {'form': form})
    
    # 处理 POST 请求（用户提交登录信息）
    def post(self, request):
        form = LoginForm(request.POST)
        if form.is_valid():
            username = form.cleaned_data.get('username')
            user = User.objects.get(username=username)
            login(request, user) # 使用 Django 的 login 函数
            request.session['username'] = username
            return redirect('app:view_big') #修改位置,重定向到可视化页面
        return render(request, 'login.html', {'form': form})


# 注销函数视图
class LogoutView(View):
    def get(self, request):
        request.session.clear() # 清除所有 session 数据，实现注销
        return redirect('app:index') # 重定向回首页

# 临时定义 create_user（实际应移至 views.py 或其他模块）
def create_user(request):
    # 示例实现，需根据实际业务逻辑调整
    username = request.POST.get('username')
    email = request.POST.get('email')
    password = request.POST.get('password')
    user = User.objects.create_user(username, email, password)
    return user

def register_view(request):
    # 同步处理注册逻辑
    user = create_user(request)
    # 异步触发邮件发送
    send_email.delay(user.id) # .delay() 是异步调用的关键
    return HttpResponse("注册成功！")

@login_required
def view_big(request):
    """渲染可视化页面"""
    return render(request, 'view_big.html')

from django.http import JsonResponse
from datetime import datetime
def get_time(request):
    """获取当前时间"""
    current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    return JsonResponse({
        'code': 200,
        'data': current_time
        })

from django.core.cache import cache
from django.views.decorators.cache import cache_page
from django.utils.decorators import method_decorator
# 使用缓存装饰器
@cache_page(60 * 15) # 缓存15分钟
def year_line_data(request):
    """获取电影年份分布数据"""
    cache_key = 'year_line_data'
    cached_data = cache.get(cache_key)
    if cached_data:
        return JsonResponse(cached_data)
    try:
        year_data = YearDistribution.objects.all().order_by('year')
        years = [str(item.year) for item in year_data]
        counts = [item.count for item in year_data]
        response_data = {
            'code': 200,
            'message': 'success',
            'data': {
                'years': years,
                'data': counts
            }
        }
        # 设置缓存
        cache.set(cache_key, response_data, 60 * 15) # 缓存15分钟
        return JsonResponse(response_data)
    except Exception as e:
        return JsonResponse({
        'code': 500,
        'message': str(e),
        'data': None
        })
        
from django.http import JsonResponse
from django.core.cache import cache
from spider.models import Movie, CountryStats
from django.db.models import Avg  # 导入 Avg 聚合函数
import logging
logger = logging.getLogger(__name__)
@cache_page(60 * 15) # 缓存15分钟
def get_stats(request):
    """获取统计数据"""
    cache_key = 'movie_stats'
    cached_data = cache.get(cache_key)
    if cached_data:
        return JsonResponse(cached_data)
    try:
        # 从预计算的统计表中获取数据
        total_movies = Movie.objects.count()
        avg_rating = Movie.objects.aggregate(avg=Avg('rating'))['avg']
        total_countries = CountryStats.objects.count()
        total_directors = Movie.objects.values('director').distinct().count()
        response_data = {
            'code': 200,
            'message': 'success',
            'data': {
                'total_movies': total_movies,
                'avg_rating': round(avg_rating, 1) if avg_rating else 0,
                'total_countries': total_countries,
                'total_directors': total_directors
            }
        }
        # 设置缓存
        cache.set(cache_key, response_data, 60 * 15)
        logger.info(f"统计数据: {response_data}")
        return JsonResponse(response_data)
    except Exception as e:
        logger.error(f"获取统计数据时出错: {str(e)}")
        return JsonResponse({
            'code': 500,
            'message': str(e),
            'data': None
        })

from django.http import JsonResponse
from django.core.cache import cache
from django.views.decorators.cache import cache_page
from spider.models import Movie
import logging
logger = logging.getLogger(__name__)
@cache_page(60 * 15) # 缓存15分钟
def get_top50_movies(request):
    """获取前50部电影数据"""
    cache_key = 'top50_movies'
    cached_data = cache.get(cache_key)
    if cached_data:
        return JsonResponse(cached_data)
    try:
        # 从数据库获取前50部电影，按评分排序
        movies = Movie.objects.all().order_by('-rating')[:50]
        # 构建响应数据
        movies_data = []
        for index, movie in enumerate(movies, 1):
            movie_data = {
                'title': movie.title,
                'rating': float(movie.rating) if movie.rating else 0,
                'year': movie.year,
                'director': movie.director or '',
                'genre': movie.genre or '',
                'intro': movie.intro or '',
                'rank': index, # 添加排名
                'poster': movie.image_url or '' # 使用 image_url 字段
            }
            movies_data.append(movie_data)
        response_data = {
            'code': 200,
            'message': 'success',
            'data': movies_data
        }  
        # 设置缓存
        cache.set(cache_key, response_data, 60 * 15) # 缓存15分钟
        logger.info(f"成功获取前50部电影数据")
        return JsonResponse(response_data)
    except Exception as e:
        logger.error(f"获取电影数据时出错: {str(e)}")
        return JsonResponse({
            'code': 500,
            'message': str(e),
            'data': None
        })
            
from django.http import HttpResponse
import requests
from django.views.decorators.cache import cache_page
import logging
logger = logging.getLogger(__name__)
@cache_page(60 * 60 * 24) # 缓存24小时
def proxy_image(request):
    """代理图片请求，解决跨域问题"""
    try:
        # 获取图片URL
        image_url = request.GET.get('url')
        if not image_url:
            return HttpResponse('Missing URL parameter', status=400)
        # 设置请求头，模拟浏览器请求
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Referer': 'https://movie.douban.com/'
        }
        # 发送请求获取图片
        response = requests.get(image_url, headers=headers, timeout=5)
        # 检查响应状态
        if response.status_code != 200:
            logger.error(f"Failed to fetch image: {image_url}, status:{response.status_code}")
            return HttpResponse('Failed to fetch image',status=response.status_code)
        # 设置响应头
        content_type = response.headers.get('Content-Type', 'image/jpeg')
        content_length = response.headers.get('Content-Length')
        # 构建响应
        http_response = HttpResponse(
            response.content,
            content_type=content_type
        )
        if content_length:
            http_response['Content-Length'] = content_length
        # 添加缓存控制头
        http_response['Cache-Control'] = 'public, max-age=86400' # 24小时缓存
        return http_response
    except requests.RequestException as e:
        logger.error(f"Error fetching image: {str(e)}")
        return HttpResponse('Error fetching image', status=500)
    except Exception as e:
        logger.error(f"Unexpected error: {str(e)}")
        return HttpResponse('Internal server error', status=500)

from django.http import JsonResponse
from django.core.cache import cache
from spider.models import CountryStats
from spider.services import WorldMapDataService
import json
import zlib
def get_worldmap_data(request):
    """世界地图数据API"""
    try:
        # 尝试从缓存获取数据
        cache_key = 'worldmap_data_v2'
        cached_data = cache.get(cache_key)
        if cached_data:
            data = json.loads(zlib.decompress(cached_data))
            # 筛选数量大于10的数据
            filtered_data = [item for item in data if item['count'] > 10]
            return JsonResponse(filtered_data, safe=False)
        # 从数据库获取数据
        stats = CountryStats.objects.filter(count__gt=10).order_by('-count') #直接筛选数量大于10的数据
        # 处理数据
        data = []
        for stat in stats:
            # 标准化国家名称
            country = WorldMapDataService._normalize_country_name(stat.country)
            if not country: # 跳过无效的国家名
                continue
            data.append({
                'country': country,
                'count': stat.count,
                'avg_rating': float(stat.avg_rating) if stat.avg_rating else 0,
                'top_movies': [
                    {
                        'title': stat.top_movie_title or '未知',
                        'rating': float(stat.top_movie_rating) if stat.top_movie_rating else 0,
                        'year': stat.top_movie_year or '未知'
                    }
                ] if stat.top_movie_title else []
            })
        # 压缩并缓存数据
        compressed_data = zlib.compress(json.dumps(data).encode())
        cache.set(cache_key, compressed_data, 3600) # 缓存1小时
        return JsonResponse(data, safe=False)
    except Exception as e:
        logger.error(f"API错误: {str(e)}")
        return JsonResponse([], safe=False)

from django.http import JsonResponse
from spider.models import MovieType
from django.core.cache import cache
import json
import zlib
import logging

logger = logging.getLogger(__name__)

def get_type_pie_data(request):
    """电影类型分布数据API"""
    try:
        # 尝试从缓存获取数据
        cache_key = 'type_pie_data'
        cached_data = cache.get(cache_key)
        if cached_data:
            data = json.loads(zlib.decompress(cached_data))
            return JsonResponse({
                'code': 200,
                'message': 'success',
                'data': data
            })

        # 从数据库获取数据
        type_data = MovieType.get_type_distribution()

        # 压缩数据并缓存（1小时）
        compressed_data = zlib.compress(json.dumps(type_data).encode())
        cache.set(cache_key, compressed_data, 3600)

        return JsonResponse({
            'code': 200,
            'message': 'success',
            'data': type_data
        })
    except Exception as e:
        logger.error(f"获取电影类型分布数据失败: {str(e)}")
        return JsonResponse({
            'code': 500,
            'message': '获取数据失败',
            'data': []
        })
    
from django.http import JsonResponse
from spider.models import Movie
from django.core.cache import cache
import json
import zlib
import logging

logger = logging.getLogger(__name__)

def get_word_cloud_data(request):
    """电影简介词云API"""
    try:
        cache_key = 'word_cloud_data'
        cached_data = cache.get(cache_key)
        if cached_data:
            data = json.loads(zlib.decompress(cached_data))
            return JsonResponse({
                'code': 200,
                'message': 'success',
                'data': data
            })
        
        data = Movie.get_word_cloud_data()
        compressed_data = zlib.compress(json.dumps(data, ensure_ascii=False).encode())
        cache.set(cache_key, compressed_data, 3600)
        
        return JsonResponse({
            'code': 200,
            'message': 'success',
            'data': data
        })
    except Exception as e:
        logger.error(f"获取词云数据失败: {str(e)}")
        return JsonResponse({
            'code': 500,
            'message': '获取数据失败',
            'data': []
        })    
    
from django.http import JsonResponse
from spider.models import RatingDistribution  # 导入 RatingDistribution 模型
from django.core.cache import cache
import json
import zlib

def get_rating_distribution(request):
    """电影评分分布API"""
    try:
        cache_key = 'rating_distribution'
        cached_data = cache.get(cache_key)
        if cached_data:
            data = json.loads(zlib.decompress(cached_data))
            return JsonResponse({
                'code': 200,
                'message': 'success',
                'data': data
            })
        
        # 直接从 RatingDistribution 模型查询数据并格式化
        raw_data = RatingDistribution.objects.all().order_by('-rating')
        
        # 将数据转换为字典格式
        data = {}
        for item in raw_data:
            data[str(item.rating)] = item.count
        
        compressed_data = zlib.compress(json.dumps(data, ensure_ascii=False).encode())
        cache.set(cache_key, compressed_data, 3600)  # 缓存1小时
        
        return JsonResponse({
            'code': 200,
            'message': 'success',
            'data': data
        })
    except Exception as e:
        logger.error(f"获取评分分布数据失败: {str(e)}")
        return JsonResponse({
            'code': 500,
            'message': '获取数据失败',
            'data': {}  # 返回空字典以匹配前端处理
        })    